home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Games / warp / move.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  16.2 KB  |  681 lines
  1. /* $Header: move.c,v 7.0.1.2 86/10/20 14:37:06 lwall Exp $ */
  2.  
  3. /* $Log:    move.c,v $
  4.  * Revision 7.0.1.2  86/10/20  14:37:06  lwall
  5.  * Picked some lint.
  6.  * 
  7.  * Revision 7.0.1.1  86/10/16  10:52:09  lwall
  8.  * Added Damage.  Fixed random bugs.
  9.  * 
  10.  * Revision 7.0  86/10/08  15:12:40  lwall
  11.  * Split into separate files.  Added amoebas and pirates.
  12.  * 
  13.  */
  14.  
  15. #include "EXTERN.h"
  16. #include "warp.h"
  17. #include "bang.h"
  18. #include "object.h"
  19. #include "move.h"
  20. #include "play.h"
  21. #include "score.h"
  22. #include "term.h"
  23. #include "them.h"
  24. #include "us.h"
  25. #include "util.h"
  26. #include "weapon.h"
  27. #include "INTERN.h"
  28. #include "move.h"
  29.  
  30. void
  31. move_init()
  32. {
  33.     ;
  34. }
  35.  
  36. void
  37. bounce(obj)
  38. Reg4 OBJECT *obj;
  39. {
  40.     Reg1 int x;
  41.     Reg2 int y;
  42.     Reg3 int count=0;
  43.  
  44.     y = (obj->posy - sgn(obj->vely) + YSIZE00) % YSIZE;
  45.     x = (obj->posx - sgn(obj->velx) + XSIZE00) % XSIZE;
  46.     while (occupant[y][x]) {
  47.     y = (y + rand_mod(3) - 1 + YSIZE00) % YSIZE;
  48.     x = (x + rand_mod(3) - 1 + XSIZE00) % XSIZE;
  49.     if (++count > 10000) {     /* if universe full, get out of it fast */
  50.         unmake_object(obj);
  51.         if (ent) unmake_object(ent);
  52.         if (base) unmake_object(base);
  53.         finish = 1;
  54.         return;
  55.     }
  56.     }
  57.     obj->posy = y;
  58.     obj->posx = x;
  59.     obj->vely = 0;
  60.     obj->velx = 0;
  61.     occupant[y][x] = obj;
  62.     if (numamoebas && obj->image == ' ')
  63.     mvaddc(y+1, x*2, amb[y][x]);
  64.     else
  65.     mvaddc(y+1, x*2, obj->image);
  66. }
  67.  
  68. void
  69. move_universe()
  70. {
  71.     Reg1 OBJECT *curobj;
  72.     Reg2 int x;
  73.     Reg3 int y;
  74.     Reg4 OBJECT *temp;
  75.     OBJECT *thenext;
  76.  
  77.     for (curobj = movers; curobj != &root; curobj = curobj->next) {
  78.     x = curobj->posx;
  79.     y = curobj->posy;
  80.     if (curobj == occupant[y][x]) {
  81.         occupant[y][x] = 0;
  82.     }
  83.     else if (curobj->type != Torp && curobj->type != Web) {
  84.         resetty();
  85.         abort();
  86.     }
  87.     }
  88.     for (curobj = movers; curobj != &root; curobj = thenext) {
  89.     thenext = curobj->next;
  90.     if (curobj->vely || curobj->velx) {
  91.         y = curobj->posy;
  92.         x = curobj->posx;
  93.         if (curobj->image != ' ' &&
  94.           (!(temp=occupant[y][x]) || temp->image==' ') ) {
  95.         move(y+1, x*2, numamoebas ? amb[y][x] : ' ');
  96.         }
  97.         y = (y + curobj->vely + YSIZE00) % YSIZE;
  98.         x = (x + curobj->velx + XSIZE00) % XSIZE;
  99.         if (!(temp=occupant[y][x]) || temp->type != Star ||
  100.           curobj->type != Torp || curobj->image == '+' ||
  101.           curobj->image == 'x') {
  102.         curobj->posy = y;
  103.         curobj->posx = x;
  104.         }
  105.         else {
  106.         if (curobj->image == '0') {
  107.             curobj->vely = rand_mod(3)-1;
  108.             curobj->velx = rand_mod(3)-1;
  109.         }
  110.         else
  111.             curobj->vely = curobj->velx = 0;
  112.         y = curobj->posy;
  113.         x = curobj->posx;
  114.         }
  115.     }
  116.     else {            /* not moving */
  117.         y = curobj->posy;
  118.         x = curobj->posx;
  119.         if (curobj->type == Torp ||
  120.         curobj->type == Star ||
  121.         curobj->type == Web) {
  122.         curobj->flags |= STATIC;
  123.         curobj->next->prev = curobj->prev;
  124.         curobj->prev->next = curobj->next;
  125.         curobj->prev = movers->prev;
  126.         curobj->next = movers;
  127.         movers->prev->next = curobj;
  128.         movers->prev = curobj;
  129.         }
  130.     }
  131.     if (temp = occupant[y][x]) {        /* already occupied? */
  132.         if (!temp->contend) {
  133.         if (temp->type == Torp) {
  134.             if (temp->image == '+')
  135.             blast[y][x] += 1250;
  136.             else if (temp->image == 'o' && (base||ent))
  137.             blast[y][x] += 500+super*20;
  138.             else if (temp->image == 'O' && (base||ent))
  139.             blast[y][x] += 5000+super*100;
  140.         }
  141.         }
  142.         yblasted[y] |= 1;
  143.         xblasted[x] |= 1;
  144.         blasted = TRUE;
  145.         curobj->contend = temp;
  146.         occupant[y][x] = curobj;
  147.         switch (curobj->type) {
  148.         case Enemy:
  149.         if (numamoebas && curobj == nuke && temp->image == '+')
  150.             blast[y][x] += 80000;
  151.         else if (temp->type == Enemy)
  152.             blast[y][x] += 10;
  153.         else
  154.             goto defblast;
  155.         break;
  156.         case Crusher:
  157.         if (curobj->velx)
  158.             blast[y][x] += 100000;
  159.         else
  160.             goto defblast;
  161.         break;
  162.         case Torp:
  163.         if (curobj->image == '+')
  164.             blast[y][x] += (temp==nuke ? 80000 : 1250);
  165.         else if (curobj->image == 'o')
  166.             blast[y][x] += 500+super*20;
  167.         else if (curobj->image == 'O')
  168.             blast[y][x] += 5000+super*100;
  169.         goto defblast;
  170.         case Star:
  171.         if (temp == ent)
  172.             goto damshield;
  173.         goto defblast;
  174.         case Enterprise:
  175.         if (temp->type == Star) {
  176.           damshield:
  177.             if (!rand_mod(10)) {
  178.             if (!damflag[NOSHIELDS])
  179.                 damage++;
  180.             if (damflag[NOSHIELDS] < 100)
  181.                 damflag[NOSHIELDS] += rand_mod(smarts)/5+2;
  182.             }
  183.         }
  184.         goto defblast;
  185.         default:
  186.           defblast:
  187.         blast[y][x] += rand_mod(751)+1;
  188.         break;
  189.         }
  190.     }
  191.     else {
  192.         occupant[y][x] = curobj;
  193.         if (curobj->image != ' ' &&
  194.             (curobj->velx || curobj->vely ||
  195.          curobj->type == Torp || curobj->type == Web) ) {
  196.         mvaddc(y+1, x*2, curobj->image);
  197.         }
  198.         if (curobj->type == Crusher && curobj->velx) {
  199.         blast[y][x] += 100000;
  200.         yblasted[y] |= 1;
  201.         xblasted[x] |= 1;
  202.         blasted = TRUE;
  203.         }
  204.     }
  205.     }
  206.     if (blasted) {
  207.     Reg7 int minxblast = -1;
  208.     Reg8 int maxxblast = -2;
  209.     Reg5 long tmpblast;
  210.  
  211.     blasted = numamoebas;
  212.     for (x=0; x<XSIZE; x++) {
  213.         if (xblasted[x]) {
  214.         xblasted[x] = 0;
  215.         maxxblast = x;
  216.         if (minxblast < 0)
  217.             minxblast = x;
  218.         }
  219.     }
  220.     for (y=0; y<YSIZE; y++) {
  221.         if (yblasted[y]) {
  222.         yblasted[y] = 0;
  223.         for (x=minxblast; x<=maxxblast; x++) {
  224.             tmpblast = blast[y][x];
  225.             if (numamoebas && amb[y][x] == '~') {
  226.             if (temp = occupant[y][x]) {
  227.                 if (temp->image == '&')
  228.                 tmpblast >>= 1;
  229.                 else if (temp->type == Web)
  230.                 tmpblast = 100000;
  231.                 else
  232.                 tmpblast += 50 + temp->energy/100;
  233.                 if (tmpblast > 250 && !rand_mod(5+(inumstars>>4)))
  234.                 modify_amoeba(y,x,1,'~',5);
  235.             }
  236.             xblasted[x] = 2;
  237.             yblasted[y] = 2;
  238.             }
  239.             if (tmpblast) {
  240.             Reg6 OBJECT *biggie = 0;
  241.  
  242.             blast[y][x] = 0;
  243.             temp = occupant[y][x];
  244.             if (tmpblast < 0) {
  245.                 if (numamoebas && tmpblast < -1000000 &&
  246.                 amb[y][x] == '~' && temp != nuke) {
  247.                 amb[y][x] = ' ';
  248.                 if (!temp)
  249.                     make_plink(y,x);
  250.                 ambsize--;
  251.                 }
  252.                 tmpblast = 0;
  253.             }
  254.             if (temp) {
  255.                 if ((!numamoebas || amb[y][x]==' ') &&
  256.                   tmpblast < 100000)
  257.                 make_plink(y,x);
  258.                 for ( ;temp;
  259.                   temp = curobj->contend,curobj->contend = 0){
  260.                 curobj = temp;
  261.                 switch (curobj->type) {
  262.                 case Enterprise: {
  263.                     long tmp = curobj->energy;
  264.  
  265.                     if (ent->energy>500 || apolloflag & 1)
  266.                     curobj->energy -= tmpblast /
  267.                        ((apolloflag & 1)
  268.                         ? 20
  269.                         : (5+abs(ent->velx)+abs(ent->vely))
  270.                            / ((damflag[NOSHIELDS]>>3)+1)+1);
  271.                     else
  272.                     curobj->energy -= tmpblast;
  273.                     if (rand_mod(1 + tmp - curobj->energy) > 100
  274.                     || ent->energy < (entmax>>1)) {
  275.                     if (debug & 128 ||
  276.                       (damage <= smarts/10 &&
  277.                        !rand_mod(6-smarts/20-massacre) )) {
  278.                         tmp = rand_mod(MAXDAMAGE);
  279.                         if (damflag[tmp]) {
  280.                         if (damflag[tmp] < 60)
  281.                           damflag[tmp] += rand_mod(60);
  282.                         }
  283.                         else {
  284.                         damflag[tmp] =
  285.                           rand_mod(smarts+10)+2;
  286.                         damage++;
  287.                         }
  288.                     }
  289.                     }
  290.                     break;
  291.                 }
  292.                 case Base:
  293.                     if (base->energy > 1000 || apolloflag & 2)
  294.                     curobj->energy -= tmpblast /
  295.                        ((apolloflag & 2)?20:5);
  296.                     else
  297.                     curobj->energy -= tmpblast;
  298.                     break;
  299.                 case Crusher:
  300.                     if (tmpblast > 132767)
  301.                     curobj->energy -= (tmpblast - 100000);
  302.                     else if (tmpblast >= 100000) {
  303.                     curobj->energy += (tmpblast - 100000);
  304.                     if (curobj->energy > 32767)
  305.                         curobj->energy = 32767;
  306.                     }
  307.                     else    /* vulnerable while feeding */
  308.                     curobj->energy -= tmpblast;
  309.                     break;
  310.                 case Enemy:
  311.                     curobj->energy -= tmpblast*10/enemshields;
  312.                     break;
  313.                 default:
  314.                     curobj->energy -= tmpblast;
  315.                     break;
  316.                 }
  317.                 if (curobj->energy < 0) {    /* killed it? */
  318.                     switch (curobj->image) {
  319.                     case 'A':
  320.                     tmpblast = 100000;
  321.                     make_blast(y,x,8192L,1);
  322.                     numapollos = apolloflag = 0;
  323.                     numstars--;
  324.                     numenemies--;
  325.                     curscore += 5000;
  326.                     deados = 0;
  327.                     break;
  328.                     case 'E': case 'e': case 'C': case 'c':
  329.                     ent = 0;
  330.                     numents--;
  331.                     if (base)
  332.                         status = 2;
  333.                     else
  334.                         status = 3;
  335.                     deados = 0;
  336.                     break;
  337.                     case 'B': case 'b':
  338.                     base = 0;
  339.                     numbases--;
  340.                     if (ent)
  341.                         status = entmode;
  342.                     else
  343.                         status = 3;
  344.                     deados = 0;
  345.                     break;
  346.                     case '&': {
  347.                     int i, xxx, yyy;
  348.  
  349.                     for (i = 0; i < YSIZE; i++)
  350.                         yblasted[i] &= 1;
  351.                     for (i = 0; i < XSIZE; i++)
  352.                         xblasted[i] &= 1;
  353.                     numamoebas = 0;    /* ignore amb[][] now */
  354.                     for (yyy = 0; yyy < YSIZE; yyy++) {
  355.                         for (xxx = 0; xxx < XSIZE; xxx++) {
  356.                         if (amb[yyy][xxx] == '~' &&
  357.                             !occupant[yyy][xxx]) {
  358.                             mvaddch(yyy+1,xxx*2,' ');
  359.                         }
  360.                         }
  361.                     }
  362.                     numenemies--;
  363.                     curscore += 10000;
  364.                     if (curobj == enemies)
  365.                         enemies = curobj->next;
  366.                     deados = 0;
  367.                     break;
  368.                     }
  369.                     case '<': case '>': {
  370.                     int i;
  371.  
  372.                     numenemies--;
  373.                     numcrushes = 0;
  374.                     curscore += 10000;
  375.                     if (curobj == movers)
  376.                         movers = curobj->next;
  377.                     if (curobj == enemies)
  378.                         enemies = curobj->next;
  379.                     deados = 0;
  380.  
  381.                     tmpblast = 100000;
  382.                     make_blast(y,(x+XSIZE00)%XSIZE,10000L,0);
  383.                     if (curobj->image == '<') {
  384.                         for (i=XSIZE00; i<=XSIZE01; i++)
  385.                         make_blast(y,(x+i)%XSIZE,
  386.                             10000L,0);
  387.                         for (i=XSIZE00; i<=XSIZE02; i++)
  388.                         make_blast(y,(x+i)%XSIZE,
  389.                             10000L,0);
  390.                         make_blast(y,(x+XSIZE03)%XSIZE,
  391.                         10000L,1);
  392.                         for (i=XSIZE00; i<=XSIZE08; i++)
  393.                         make_blast(y,(x+i)%XSIZE,
  394.                             10000L,0);
  395.                     }
  396.                     else {
  397.                         for (i=XSIZE00; i>=XSIZE99; i--)
  398.                         make_blast(y,(x+i)%XSIZE,
  399.                             10000L,0);
  400.                         for (i=XSIZE00; i>=XSIZE98; i--)
  401.                         make_blast(y,(x+i)%XSIZE,
  402.                             10000L,0);
  403.                         make_blast(y,(x+XSIZE97)%XSIZE,
  404.                         10000L,1);
  405.                         for (i=XSIZE00; i>=XSIZE92; i--)
  406.                         make_blast(y,(x+i)%XSIZE,
  407.                             10000L,0);
  408.                     }
  409.                     }
  410.                     break;
  411.                     case 'K':
  412.                     numenemies--;
  413.                     curscore += curobj->mass;
  414.                     if (curobj == enemies)
  415.                         enemies = curobj->next;
  416.                     deados = 0;
  417.                     break;
  418.                     case 'T':
  419.                     numenemies--;
  420.                     curscore += curobj->mass*3/2;
  421.                     if (curobj == enemies)
  422.                         enemies = curobj->next;
  423.                     deados = 0;
  424.                     break;
  425.                     case 'R': case ' ': case 'P':
  426.                     numenemies--;
  427.                     if (curobj->flags & PIRATE)
  428.                         curscore += curobj->mass;
  429.                     else
  430.                         curscore += curobj->mass*3;
  431.                     if (curobj == enemies)
  432.                         enemies = curobj->next;
  433.                     deados = 0;
  434.                     break;
  435.                     case 'G':
  436.                     numenemies--;
  437.                     numgorns--;
  438.                     tmpblast = 100000;
  439.                     if (madgorns)
  440.                         curscore += curobj->mass/2;
  441.                     else
  442.                         curscore += curobj->mass*2;
  443.                     if (curobj == enemies)
  444.                         enemies = curobj->next;
  445.                     {
  446.                         int xxx,yyy;
  447.  
  448.                         for (xxx = -1; xxx<=1; xxx++)
  449.                         for (yyy = -1; yyy<=1; yyy++)
  450.                             if (rand_mod(2+massacre))
  451.                             fire_torp(curobj,
  452.                                 yyy,xxx);
  453.                     }
  454.                     deados = 0;
  455.                     break;
  456.                     case '@':
  457.                     numinhab--;
  458.                     /* FALL THROUGH */
  459.                     case '*':
  460.                     banging = TRUE;
  461.                     numstars--;
  462.                     break;
  463.                     case '|': case '-': case '/': case '\\':
  464.                     tmpblast = 100000;
  465.                     make_blast(y,x,curobj->mass,1);
  466.                     banging = TRUE;
  467.                     deados = 0;
  468.                     break;
  469.                     case 'x':
  470.                     curscore += 10;
  471.                     deados = 0;
  472.                     break;
  473.                     case 'X':
  474.                     curscore += 100;
  475.                     numxes--;
  476.                     deados = 0;
  477.                     break;
  478.                     case '0':
  479.                     curscore += 35;
  480.                     numos--;
  481.                     deados += 3;
  482.                     break;
  483.                     case 'o':
  484.                     curscore += 100;
  485.                     numos--;
  486.                     deados++;
  487.                     break;
  488.                     case 'O':
  489.                     curscore += 200;
  490.                     numos--;
  491.                     deados += 2;
  492.                     break;
  493.                     case 'M':
  494.                     deadmudds++;
  495.                     inumfriends--;
  496.                     numfriends--;
  497.                     if (curobj == enemies)
  498.                         enemies = curobj->next;
  499.                     break;
  500.                     case 'Q': case 'W': case 'Y': case 'U':
  501.                     case 'I': case 'S': case 'D': case 'H':
  502.                     case 'J': case 'L': case 'Z': case 'V':
  503.                     case 'F':
  504.                     numfriends--;
  505.                     if (curobj == enemies)
  506.                         enemies = curobj->next;
  507.                     if (inumfriends < 10)
  508.                         madfriends += 500;
  509.                     else
  510.                         madfriends += 10000/inumfriends;
  511.                     break;
  512.                     }
  513.                     if (tmpblast < 100000)
  514.                     make_blast(y,x,curobj->mass,1);
  515.                     unmake_object(curobj);
  516.                 }
  517.                 else {        /* didn't kill anything */
  518.                     if (!biggie)
  519.                     biggie = curobj;
  520.                     else {
  521.                     if (biggie->mass > curobj->mass)
  522.                         bounce(curobj);
  523.                     else {
  524.                         bounce(biggie);
  525.                         biggie = curobj;
  526.                     }
  527.                     }
  528.                 }
  529.                 }
  530.                 if (biggie) {
  531.                 occupant[y][x] = biggie;
  532.                 if (numamoebas && biggie->image == ' ')
  533.                     mvaddch(y+1,x*2, amb[y][x]);
  534.                 else
  535.                     mvaddch(y+1,x*2, biggie->image);
  536.                 }
  537.                 else {
  538.                 occupant[y][x] = 0;
  539.                 mvaddch(y+1, x*2, numamoebas ? amb[y][x] : ' ');
  540.                 }
  541.             }
  542.             }
  543.         }
  544.         }
  545.     }
  546.     }
  547.     do_bangs();
  548.     if (numcrushes && movers->type == Crusher)
  549.     movers->vely = 0;
  550.     if (curobj = base) {
  551.     char ch;
  552.  
  553.     curobj->velx = 0;
  554.     curobj->vely = 0;
  555.     curobj->energy += 25*lookaround(curobj->posy,curobj->posx,Star);
  556.     if (curobj->energy > basemax)
  557.         curobj->energy = basemax;
  558.     if (curobj->energy >= 1000)
  559.         ch = 'B';
  560.     else
  561.         ch = 'b';
  562.     if (ch != curobj->image) {
  563.         setimage(curobj, ch);
  564.     }
  565.     }
  566.     if (curobj = ent) {
  567.     char ch;
  568.  
  569.     if (entmode == 0) {
  570.         curobj->velx = 0;
  571.         curobj->vely = 0;
  572.     }
  573.     if (base && !cloaking && !curobj->velx && !curobj->vely &&
  574.       lookfor(curobj->posy,curobj->posx,Base)) {
  575.         int tmp;
  576.  
  577. #ifdef lint
  578.         tmp = 0;
  579. #else
  580.         tmp = (int) (base->energy - 1000 < entmax - curobj->energy ?
  581.                  base->energy - 1000 : entmax - curobj->energy);
  582. #endif
  583.         if (tmp < 0)
  584.         tmp = 0;
  585.         curobj->energy += tmp;
  586.         base->energy -= tmp;
  587.         tmp = (btorp < 50 - etorp ?
  588.            btorp : 50 - etorp);
  589.         etorp += tmp;
  590.         btorp -= tmp;
  591.         if (damage) {
  592.         tmp = rand_mod(MAXDAMAGE);
  593.         if (damflag[tmp] > 5) {
  594.             damflag[tmp] = rand_mod(5)+1;
  595.         }
  596.         }
  597.     }
  598.     if (curobj->energy >= 500 && (!damage || !damflag[NOSHIELDS]))
  599.         ch = cloaked?'C':'E';
  600.     else
  601.         ch = cloaked?'c':'e';
  602.     if (ch != curobj->image) {
  603.         setimage(curobj, ch);
  604.     }
  605.     }
  606. }
  607.  
  608. int
  609. lookaround(y, x, what)
  610. Reg1 int y;
  611. Reg2 int x;
  612. Reg4 char what;
  613. {
  614.     Reg3 OBJECT *obj;
  615.     Reg5 int count=0;
  616.     Reg6 int xp;
  617.     Reg7 int xm;
  618.  
  619.     if ((obj=occupant[y][xp=(x+XSIZE01)%XSIZE])&&obj->type == what) /* 0, 1 */
  620.     count++;
  621.     if ((obj=occupant[y][xm=(x+XSIZE99)%XSIZE])&&obj->type == what) /* 0, -1 */
  622.     count++;
  623.     if ((obj=occupant[y=(y+YSIZE99)%YSIZE][xp])&&obj->type == what) /* -1, 1 */
  624.     count++;
  625.     if ((obj=occupant[y][x])&&obj->type == what)                    /* -1, 0 */
  626.     count++;
  627.     if ((obj=occupant[y][xm])&&obj->type == what)                   /* -1, -1 */
  628.     count++;
  629.     if ((obj=occupant[y=(y+2)%YSIZE][xp])&&obj->type == what)       /* 1, 1 */
  630.     count++;
  631.     if ((obj=occupant[y][x])&&obj->type == what)                    /* 1, 0 */
  632.     count++;
  633.     if ((obj=occupant[y][xm])&&obj->type == what)                   /* 1, -1 */
  634.     count++;
  635.     return (count);
  636. }
  637.  
  638. int
  639. lookfor(y, x, what)
  640. Reg1 int y;
  641. Reg2 int x;
  642. Reg4 char what;
  643. {
  644.     Reg3 OBJECT *obj;
  645.     Reg5 int xp;
  646.     Reg6 int xm;
  647.  
  648.     if ((obj=occupant[y][xp=(x+XSIZE01)%XSIZE])&&obj->type == what ||/* 0, 1 */
  649.         (obj=occupant[y][xm=(x+XSIZE99)%XSIZE])&&obj->type == what ||/* 0, -1 */
  650.         (obj=occupant[y=(y+YSIZE99)%YSIZE][xp])&&obj->type == what ||/* -1, 1 */
  651.         (obj=occupant[y][x])&&obj->type == what                    ||/* -1, 0 */
  652.         (obj=occupant[y][xm])&&obj->type == what                   ||/* -1,-1 */
  653.         (obj=occupant[y=(y+2)%YSIZE][xp])&&obj->type == what       ||/* 1, 1 */
  654.         (obj=occupant[y][x])&&obj->type == what                    ||/* 1, 0 */
  655.         (obj=occupant[y][xm])&&obj->type == what)                    /* 1, -1 */
  656.     return(1);
  657.     return (0);
  658. }
  659.  
  660. OBJECT*
  661. lookimg(y, x, what)
  662. Reg1 int y;
  663. Reg2 int x;
  664. Reg4 char what;
  665. {
  666.     Reg3 OBJECT *obj;
  667.     Reg5 int xp;
  668.     Reg6 int xm;
  669.  
  670.     if ((obj=occupant[y][xp=(x+XSIZE01)%XSIZE])&&obj->image==what ||/* 0, 1 */
  671.         (obj=occupant[y][xm=(x+XSIZE99)%XSIZE])&&obj->image==what ||/* 0, -1 */
  672.         (obj=occupant[y=(y+YSIZE99)%YSIZE][xp])&&obj->image==what ||/* -1, 1 */
  673.         (obj=occupant[y][x])&&obj->image==what                    ||/* -1, 0 */
  674.         (obj=occupant[y][xm])&&obj->image==what                   ||/* -1,-1 */
  675.         (obj=occupant[y=(y+2)%YSIZE][xp])&&obj->image==what       ||/* 1, 1 */
  676.         (obj=occupant[y][x])&&obj->image==what                    ||/* 1, 0 */
  677.         (obj=occupant[y][xm])&&obj->image==what)                    /* 1, -1 */
  678.     return obj;
  679.     return Null(OBJECT*);
  680. }
  681.